#include <iostream>
#include <math.h>

using namespace std;
const int MAXNUM = 20;


bool isPrime(int n)
{
	if (n <= 3)
		return true;
	int sq = (int)sqrt(n * 1.0);
	for (int i = 2; i <= sq; i++) {
		if (n % i == 0) {
			return false;
		}
	}
	return true;
}


//
//void calculate(int **factors, int &size, int n)
//{
//	if (size == 0) {
//		factors[size][0] = 1;
//		factors[size][1] = 0;
//		++size;
//	}
//
//	if (size == 1) {
//		factors[size][0] = 1;
//		factors[size][1] = 1;
//		++size;
//	}
//
//	if (n <= size)
//		return;
//
//	int maxLength = 0, number = 0;
//	bool isPrime = true;
//	for (int j = size; j < n; ++j) {
//		isPrime = true;
//		maxLength = 0;
//		number = 0;
//		for (int k = (j + 1) / 2; k >= 2; --k) {
//			if ((j + 1) % k == 0) {
//				isPrime = false;
//				if (factors[k - 1][0] >= maxLength) {
//					maxLength = factors[k - 1][0];
//				}
//			}
//		}
//		factors[j][0] = maxLength + 1;
//
//		for (int k = (j + 1) / 2; k >= 2; --k) {
//			if ((j + 1) % k == 0) {
//				if (factors[k - 1][0] == maxLength) {
//					number += factors[k - 1][1];
//				}
//			}
//		}
//		if (!isPrime)
//			factors[j][1] = number;
//		else 
//			factors[j][1] = 1;
//	}
//	size = n;
//}

long long powModel(int a, int d, int n)
{
	long long tempA = a;
	long long single = 1;
	while (d > 1) {
		if (d % 2 == 1) {
			single = (single * tempA) % n;
		}
		tempA = (tempA * tempA) % n;
		d /= 2;
	}

	tempA = (single * tempA) % n;
	
	return tempA;
}

bool isPrimable(int base, int d, int r, int n) 
{
	long long model = powModel(base, d, n);
	if (model == 1 || model == n - 1)
		return true;

	//long long *inter = new long long[r];
	//for (int i = 0; i < r; i++) {
	//	model = ((model % n) * (model % n)) % n;
	//	inter[i] = model;
	//}

	//int idx = r - 1;
	//while (inter[idx] == 1) {
	//	--idx;
	//}

	//if (inter[idx] == n - 1) {
	//	delete[] inter;
	//	return true;
	//}
	//delete[] inter;
	//return false;

	for (int i = 0; i < r; i++) {
		model = ((model % n) * (model % n)) % n;
		if (model == n - 1)
		{
			return true;
		}
	}

	return false;
}

bool isPrimable(int n) 
{
	int d = -1, r = 0;
	int origin = n;	
	--n;
	while (n > 0) {
		if (n % 2 == 0) {
			n /= 2;
			++r;
		} else {
			d = n;
			break;
		}
	}

	n = origin;
	int base = 2;
	if (isPrimable(base, d, r, n)) {
		if (n <=3)
			base = 2;
		else
			base = 3;
		if (isPrimable(base, d, r, n)) {
			return true;
		}
	}
	return false;
}

int nextPrime(int n)
{
	while (true) {
		if (n == 2)
			++n;
		else 
			n += 2;
		if (isPrimable(n))
			return n;
	}
}


int getCombination(int combination[MAXNUM][MAXNUM + 1], int &size, int n, int k)
{
	if (n < size)
		return combination[n - 1][k];

	if (size == 0) {
		combination[size][0] = 1;
		combination[size][1] = 1;
		++size;
	}

	for (int i = size; i < n; i++) {
		for (int j = 0; j <= (i + 1); j++) {
			int tmp = j < 1 ? 0 : combination[i - 1][j - 1];
			int tmp1 = j > i ? 0 : combination[i - 1][j];
			combination[i][j] = tmp + tmp1;
		}
	}

	size = n;
	return combination[n - 1][k];
}


int main(int argc, char *args[])
{
	
	int primeFactors[MAXNUM];
	int combination[MAXNUM][MAXNUM + 1];
	int size = 0;
	//const int MAX = 524288;
	/*int **factors = new int*[MAX];
	for (int i = 0; i < MAX; i++) {
		factors[i] = new int[2];
	}*/
	//int factors[MAX][2];
	int n;
	while (cin>>n) {
		//memset(primeFactors, 0, sizeof(int) * MAXNUM);
		for (int i = 0; i < MAXNUM; i++) {
			primeFactors[i] = 0;
		}
		///*calculate(factors, size, n);
		//cout<<factors[n - 1][0]<<" "<<factors[n - 1][1]<<endl;*/
		int numberOfPrimeFactors = 0;
		int next = 2;
		bool isUpdated = false;
		while (n > 1) {
			if (n % next == 0) {
				if (!isUpdated) {
					++numberOfPrimeFactors;
					isUpdated = true;
				}
				primeFactors[numberOfPrimeFactors - 1]++;
				n /= next;
			} else {
				if (isPrimable(n))
					next = n;
				else
					next = nextPrime(next);
				isUpdated = false;
			}	
		}

		int m = 0;
		int means = 1;
		for (int i = 0; i < numberOfPrimeFactors; i++) {
			m += primeFactors[i];
		}

		int origin = m;
		for (int i = 0; i < numberOfPrimeFactors; i++) {
			means *= getCombination(combination, size, m, primeFactors[i]);
			m -= primeFactors[i];
		}

		cout<<origin<<" "<<means<<endl;

		//for (int i = 1001; i <= 2047; ++i) {
		//	if (isPrimable(i)/*powModel(2, i - 1, i) == 1*/) {
		//		cout<<i<<" ";
		//		if (isPrime(i))
		//			cout<<i<<endl;
		//		else
		//			cout<<endl;
		//	} else {
		//		if (isPrime(i))
		//			cout<<"     "<<i<<endl;
		//	}
		//}
	}

	/*for (int i = 0; i < MAX; i++) {
		delete[] factors[i];
	}
	delete[] factors;*/
	return 0;
}